import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;

/**
 * @author ：冯涛滔
 * @date ：Created in 2020-4-7 19:49
 * @description：
 * @modified By：
 * @version:
 */
public class Sum {
    public static void main(String[] args) {
        Scanner in = new Scanner(new InputStreamReader(System.in));
        DecimalFormat decimalFormat = new DecimalFormat("#.00");
        while (in.hasNextDouble()){
            double sum = in.nextDouble();
            sum+= in.nextDouble();
            if(sum%1!=0){
                System.out.print("这是一个浮点数，它的值为："+String.format("%.2f",sum));
            }else{
                System.out.println("这是一个伪整数，它的值为：" + (int)sum);

            }
        }
    }

    //合并区间
    public int[][] merge(int[][] intervals) {
        if(intervals.length==0){
            return new int[0][2];
        }
        Arrays.sort(intervals, (v1, v2) -> v1[0] - v2[0]); //根据开头进行升序排序
        int[][] res = new int[intervals.length][2];
        int t = 0;
        res[0][0] = intervals[0][0];
        res[0][1] = intervals[0][1];
        for (int i = 1; i < intervals.length; i++) {
            if(intervals[i][0]<=res[t][1]){ //如果第i行的开头小于等于 res[t]的结尾合并
                res[t][1] = Math.max(intervals[i][1],res[t][1]);// res[t] 设为最大值
            }else{
                t++;
                res[t][0] =  intervals[i][0];
                res[t][1] =  intervals[i][1];
            }
        }
        return Arrays.copyOfRange(res,0,t+1);
    }
    public static int threeSumClosest(int[] nums, int target) {
        int len = nums.length;
        int min = 999;
        int result = 0;
        Arrays.sort(nums); //升序排序
        for (int i = 0; i < len; i++) {
            int l = i+1;
            int r = len-1;
            int sum = 0;
            while(l<r){
                sum = nums[l]+nums[r]+nums[i]; //和
                int sum2 = target-sum; //差值
                int sum3 = Math.abs(sum2); //绝对值
                if(min>sum3){
                    min = sum3;
                    result = sum;
                }
                if(sum==target){
                    return sum;
                }
                if(sum>target){
                    r--;
                }else{
                    l++;
                }
            }
        }
        return result;
    }
    public static List<List<Integer>> treeSum(int[] nums) {
        List<List<Integer>> ans = new ArrayList<>();
        int len = nums.length;
        Arrays.sort(nums); // 排序
        if(nums == null || len < 3) return ans;
        for (int i = 0; i < len; i++) {
            if(nums[i]>0)break; //如果这个大于0
            if(i > 0 && nums[i] == nums[i-1]) continue; // 去重
            int l= i+1;
            int r = len-1;
            while(l<r){
                int sum = nums[l]+nums[r]+nums[i];
                if(sum==0){
                    ans.add(Arrays.asList(nums[i],nums[l],nums[r]));
                        while(l<r&&nums[l]==nums[l+1])l++;
                        while(l<r&&nums[r]==nums[r-1])r--;
                        l++;
                        r--;
                }else {
                    if(sum>0){
                        r--;
                    }else {
                        if (sum<0) l++; //小于0
                    }
                }

            }
        }
        return ans;
    }
    /**
     * 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
     *
     * 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
     *
     * 示例:
     *
     * 给定 nums = [2, 7, 11, 15], target = 9
     *
     * 因为 nums[0] + nums[1] = 2 + 7 = 9
     * 所以返回 [0, 1]
     * @param nums
     * @param target
     * @return
     */
    public int[] twoSum(int[] nums, int target) {
        int[] result = new int[2];
        HashMap<Integer,Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            if(map.containsKey(nums[i])){
                result[0] = i;
                result[1] = map.get(nums[i]);
                return result;
            }
            map.put(target-nums[i],i);
        }
//        int[] indexs = new int[2];
//        // 建立k-v ，一一对应的哈希表
//        HashMap<Integer,Integer> hash = new HashMap<Integer,Integer>();
//        for(int i = 0; i < nums.length; i++){
//            if(hash.containsKey(nums[i])){
//                indexs[0] = i;
//                indexs[1] = hash.get(nums[i]);
//                return indexs;
//            }
//            // 将数据存入 key为补数 ，value为下标
//            hash.put(target-nums[i],i);
//        }
//        return indexs;

//        int[] r = new int[2];
//        for (int i = 0; i < nums.length; i++) {
//            if(nums[i]>target){
//                continue;
//            }
//            for (int i1 = i+1; i1 < nums.length; i1++) {
//                if(nums[i]+nums[i1]==target){
//                    r[0] = i;
//                    r[1] = i1;
//                    i = nums.length;
//                    break;
//                }
//            }
//        }
//        return r;
        return result;
    }
}
